package cn.itcalvin.sncoal.cth.controller;

import cn.itcalvin.sncoal.cth.aspect.LogAnnotation;
import cn.itcalvin.sncoal.cth.component.ConfigCacheUtils;
import cn.itcalvin.sncoal.cth.pojo.common.ReqLong;
import cn.itcalvin.sncoal.cth.pojo.common.RespSelect;
import cn.itcalvin.sncoal.cth.pojo.req.analyse.ReqAnalyseGetZbDetails;
import cn.itcalvin.sncoal.cth.pojo.response.analyse.RespAnalyse;
import cn.itcalvin.sncoal.cth.pojo.response.analyse.RespAnalyseCard;
import cn.itcalvin.sncoal.cth.pojo.response.analyse.RespAnalyseCardDetails;
import cn.itcalvin.sncoal.cth.service.AnalyseService;
import cn.itcalvin.sncoal.cth.service.InfoMineService;
import cn.itcalvin.sncoal.cth.utils.JwtUtil;
import cn.itcalvin.vo.Message;
import cn.itcalvin.vo.MessageUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.val;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.*;
import java.util.stream.Collectors;

@Api(tags = "数据分析")
@RestController
@RequestMapping("/api/analyse")
public class AnalyseController {



    @Resource
    InfoMineService infoMineService;

    @Resource
    AnalyseService analyzeService;


    @LogAnnotation(value = "获取系统列表")
    @ApiOperation(value = "获取系统列表")
    @PostMapping("getSystemList")
    public Message<List<RespSelect>> getSystemList(){
        final val collect = ConfigCacheUtils.getInstance().getAllSystemList().stream().map(v -> {
            return new RespSelect(v.getId(), v.getSystemName());
        }).collect(Collectors.toList());
        return MessageUtil.success(collect);
    }
    @LogAnnotation(value = "获取矿井列表")
    @ApiOperation(value = "获取矿井列表")
    @PostMapping("getMineList")
    public Message<List<RespSelect>> getMineList(){
        final val userInfo = JwtUtil.getUserInfo();
        if(userInfo.getRoleType()==4){
            return MessageUtil.success(Arrays.asList(new RespSelect(userInfo.getBelongId(), userInfo.getBelongName())));
        }else{
            final val allMineList = infoMineService.getAllMineList(null);
            final val collect = allMineList.getData().stream().map(v -> {
                return new RespSelect(v.getId(), v.getMineName());
            }).collect(Collectors.toList());
            return MessageUtil.success(collect);
        }
    }



    /**
     * 单个矿井各系统的得分趋势（查询条件是矿井，时间范围是近6个月，X坐标是系统，Y坐标是得分）
     * @return
     */
    @ApiOperation(value = "各矿各系统的得分趋势（查询条件是矿井，时间范围是近6个月，X坐标是系统，Y坐标是得分）")
    @LogAnnotation(value = "各矿各系统的得分趋势（查询条件是矿井，时间范围是近6个月，X坐标是系统，Y坐标是得分）")
    @PostMapping("oneMineAllSystem")
    public Message<RespAnalyse> oneMineAllSystem(@RequestBody @Valid ReqLong reqId){
        return MessageUtil.success(analyzeService.oneMineAllSystem(reqId));
    }


    /**
     * 矿井最后一次所有系统的得分
     * 最后一次两矿各系统的柱状图（X坐标是系统，Y坐标是得分）
     * 矿井查询自己的，矿业公司查询所属矿井的
     * @return
     */
    @ApiOperation(value = "最后一次两矿各系统的柱状图（X坐标是系统，Y坐标是得分）")
    @LogAnnotation(value = "最后一次两矿各系统的柱状图（X坐标是系统，Y坐标是得分）")
    @PostMapping("mineAllSystemLast")
    public Message<RespAnalyse> mineAllSystemLast(){
        return MessageUtil.success(analyzeService.mineAllSystemLast());
    }


    /**
     * 多个矿井某系统的得分趋势图 （按月，如果一个月有多次，取分数最高的一次）（需查询条件-选择某系统，时间范围是近一年，X坐标是日期，Y坐标是得分）
     * （X坐标是日期，Y坐标是得分）
     * 矿井查询自己的，矿业公司查询所属矿井的
     * @param reqId 系统ID
     * @return
     */
    @ApiOperation(value = "矿井某系统的得分趋势图")
    @LogAnnotation(value = "矿井某系统的得分趋势图")
    @PostMapping("mineOneSystem")
    public Message<RespAnalyse> mineOneSystem(@RequestBody @Valid ReqLong reqId){
        return MessageUtil.success(analyzeService.mineOneSystem(reqId));
    }

    /**
     * 多个矿井总分分趋势图（按月，如果一个月有多次，取分数最高的一次，时间范围是近半年）
     * 最后一次两矿各系统的柱状图（X坐标是日期，Y坐标是得分）
     * @return
     */
    @ApiOperation(value = "多个矿井总分分趋势图")
    @LogAnnotation(value = "多个矿井总分分趋势图")
    @PostMapping("mineDateScore")
    public Message<RespAnalyse> mineDateScore(){
        return MessageUtil.success(analyzeService.mineDateScore());
    }


    /**
     * 获取数据概览  两矿最后一次的总分
     *
     * @return
     */
    @ApiOperation(value = "获取数据概览  两矿最后一次的总分")
    @LogAnnotation(value = "获取数据概览  两矿最后一次的总分")
    @PostMapping("getStatData")
    public Message<RespAnalyseCard> getStatData(){
        return MessageUtil.success(analyzeService.getStatData());
    }

    /**
     * 获取数据概览--各系统的各项指标
     * 16个系统，可以多选进行赛选，总分是必须显示的
     * @return
     */
    @ApiOperation(value = "获取数据概览16个系统，可以多选进行赛选，总分是必须显示的")
    @LogAnnotation(value = "获取数据概览16个系统，可以多选进行赛选，总分是必须显示的")
    @PostMapping("getStatDataCard")
    public Message<Map<String, List<RespAnalyseCard>>> getStatDataCard(){
        return MessageUtil.success(analyzeService.getStatDataCard());
    }

    /**
     * 获取某个卡片的指标明细
     * 如果是矿井账号，只能看自己，其他账号是可以看多个矿
     * @param reqAnalyseGetZbDetails
     * @return
     */
    @ApiOperation(value = "获取某个卡片的指标明细")
    @LogAnnotation(value = "如果是矿井账号，只能看自己，其他账号是可以看多个矿")
    @PostMapping("getCardDetails")
    public Message<List<RespAnalyseCardDetails>> getCardDetails(
            @RequestBody @Valid ReqAnalyseGetZbDetails reqAnalyseGetZbDetails){
        return MessageUtil.success(analyzeService.getCardDetails(reqAnalyseGetZbDetails));
    }



    /**
     * 某个指标的趋势图（展示最近一年，X坐标是日期，Y是值）
     * 矿井查询自己的，矿业公司查询所属矿井的
     * @param reqId 指标明细ID
     * @return
     */
    @ApiOperation(value = "某个指标的趋势图（展示最近一年，X坐标是日期，Y是值）")
    @LogAnnotation(value = "某个指标的趋势图（展示最近一年，X坐标是日期，Y是值）")
    @PostMapping("oneZbDetails")
    public Message<RespAnalyse> oneZbDetails(@RequestBody @Valid ReqLong reqId){
        return MessageUtil.success(analyzeService.oneZbDetails(reqId));
    }




}
